




class Alg3 {
    public static <T extends Comparable<T>> T findMax(T[] array) {
        T max=array[0];
        for(int i=1;i<array.length;i++) {
            if(array[i].compareTo(max)>0) {
                max=array[i];
            }
        }
        return max;
    }

    public static void main(String[] args) {
        Integer[] arr={34,6,2,8};
        System.out.println(Alg3.<Integer>findMax(arr));
    }
}





//泛型方法
class Alg2 {
    public <T extends Comparable<T>> T findMax(T[] array) {
        T max=array[0];
        for(int i=1;i<array.length;i++) {
            if(array[i].compareTo(max)>0) {
                max=array[i];
            }
        }
        return max;
    }

    public static void main(String[] args) {
        Alg2 alg2=new Alg2();
        Integer[] arr={34,6,2,8};
        System.out.println(alg2.<Integer>findMax(arr));
    }
}

















//泛型的上界
//定义一个泛型类，倒找数组当中的最大值，没有指定数组类型
class Alg<T extends Comparable<T>> {    //限定传入的T值一定实现了Comparable接口
    public T findMax(T[] array) {
        T max=array[0];
        for(int i=1;i<array.length;i++) {
            if(array[i].compareTo(max)>0) {  //引用数据类型的比较需要实现Comparable接口，调用CompareTo进行比较
                //但是你不清楚这里的T到底是什么类型，它不是一定能进行比较的。
                //且经过类型擦除后变成Object，但是源码中Object没有实现任何接口
                max=array[i];
            }
        }
        return max;
    }

    public static void main(String[] args) {
        Alg<Integer>  alg=new Alg<>();
        Integer[] arr={1,4,3,5,7};//装箱
        System.out.println(alg.findMax(arr));
    }
}







/**
 *
 * @param <T> :代表当前类是泛型类
 */
class MyArr2<T>{
    public Object[] arr=new Object[10];
//    public T[] arr2=new (T)[10];

    public T[] arr2=(T[])new Object[10];

    public void set(int pos,T x) {
        arr[pos]=x;
    }
    public T get(int pos) {
        return (T)arr[pos];
    }

    public T[] getArray() {
        return arr2;
    }


    public static void main(String[] args) {
        MyArr2<String> myArr4=new MyArr2<>();
        String[] strings=myArr4.getArray();
    }
    public static void main1(String[] args) {

        MyArr2<Integer> myArr2=new MyArr2<>();

//        MyArr2<int> myArr3=new MyArr2<int>();//尖括号中不能放基本类型

        myArr2.set(0,1);
//        myArr2.set(1,1.0);
//        myArr2.set(2,"hello");
        Integer x=myArr2.get(0);
        System.out.println(x);
    }
}

class MyArr<T>{
    public Object[] arr=new Object[10];

    public void set(int pos,Object x) {
        arr[pos]=x;
    }
    public Object get(int pos) {
        return arr[pos];
    }
}

public class Generics {
    public static void main(String[] args) {
        MyArr myArr=new MyArr();
        myArr.set(0,1);
        myArr.set(1,1.0);
        myArr.set(2,"hello");
//        String s=myArr.get(2);//报错，因为get的返回类型是Object，要进行强制类型转换
        String s=(String)myArr.get(2);
    }
}
